{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Transformers installation\n",
    "! pip install transformers datasets evaluate accelerate\n",
    "# To install from source instead of the last release, comment the command above and uncomment the following one.\n",
    "# ! pip install git+https://github.com/huggingface/transformers.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ملخص عن المجزئات اللغوية"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "في هذه الصفحة، سنتناول بالتفصيل عملية التجزئة."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/VFp38yj8h3A?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title\n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/VFp38yj8h3A?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "كما رأينا في [برنامج تعليمي حول المعالجة المسبقة](https://huggingface.co/docs/transformers/main/ar/preprocessing)، فإن تجزئة النص يقسمه إلى كلمات أو\n",
    "الرموز الفرعية (كلمات جزئية)، والتي يتم بعد ذلك تحويلها إلى معرفات من خلال قائمة بحث. يعد تحويل الكلمات أو الرموز الفرعية إلى معرفات مباشرًا، لذا في هذا الملخص، سنركز على تقسيم النص إلى كلمات أو رموز فرعية (أي تجزئة النص).\n",
    "وبشكل أكثر تحديدًا، سنلقي نظرة على الأنواع الثلاثة الرئيسية من المُجزئات اللغوية المستخدمة في 🤗 المحولات: [ترميز الأزواج البايتية (BPE)](#byte-pair-encoding)، [WordPiece](#wordpiece)، و [SentencePiece](#sentencepiece)، ونعرض أمثلة\n",
    "على نوع المُجزئة الذي يستخدمه كل نموذج.\n",
    "\n",
    "لاحظ أنه في كل صفحة نموذج، يمكنك الاطلاع على وثائق المُجزئة المرتبط لمعرفة نوع المُجزئ\n",
    "الذي استخدمه النموذج المُدرب مسبقًا. على سبيل المثال، إذا نظرنا إلى `BertTokenizer`، يمكننا أن نرى أن النموذج يستخدم [WordPiece](#wordpiece)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## مقدمة"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "إن تقسيم النص إلى أجزاء أصغر هو مهمة أصعب مما تبدو، وهناك طرق متعددة للقيام بذلك.\n",
    "على سبيل المثال، دعنا نلقي نظرة على الجملة `\"Don't you love 🤗 Transformers? We sure do.\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/nhJxYji1aho?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title\n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/nhJxYji1aho?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "يمكن تقسيم  هذه الجملة ببساطة عن طريق  المسافات، مما  سينتج عنه ما يلي:```\n",
    "\n",
    "```\n",
    "[\"Don't\", \"you\", \"love\", \"🤗\", \"Transformers?\", \"We\", \"sure\", \"do.\"]\n",
    "```\n",
    "\n",
    "هذه خطوة أولى منطقية، ولكن إذا نظرنا إلى الرموز `\"Transformers?\"` و `\"do.\"`، فإننا نلاحظ أن علامات الترقيم مُرفقة بالكلمات `\"Transformer\"` و `\"do\"`، وهو أمر ليس مثالي. يجب أن نأخذ علامات الترقيم في الاعتبار حتى لا يضطر النموذج إلى تعلم تمثيل مختلف للكلمة وكل رمز ترقيم مُحتمل قد يليها، الأمر الذي من شأنه أن يزيد بشكل هائل عدد التمثيلات التي يجب على النموذج تعلمها.\n",
    "مع مراعاة علامات الترقيم، سيُصبح تقسيم  نصنا  على النحو التالي:\n",
    "\n",
    "```\n",
    "[\"Don\", \"'\", \"t\", \"you\", \"love\", \"🤗\", \"Transformers\", \"?\", \"We\", \"sure\", \"do\", \".\"]\n",
    "```\n",
    "\n",
    "أفضل. ومع ذلك، من غير الملائم كيفية تقسيم الكلمة `\"Don't\"`. `\"Don't\"` تعني `\"do not\"`، لذا سيكون من الأفضل تحليلها على أنها كلمتين  مُدمجتين `[\"Do\"، \"n't\"]`. هنا تبدأ الأمور في التعقيد، وهو جزء من سبب امتلاك كل نموذج لنوّعه  الخاص من مُجزّئ  النصوص (tokenizer). اعتمادًا على القواعد التي نطبقها لتقسيم النص، يسيتم إنشاء مخرجات مُجزّأة  مُختلفة لنفس النص. ولن يؤدي النموذج المُدرب مسبقًا إلى الأداء بشكل صحيح إلا إذا  قُدّم  له مُدخل تم تقسيمه بنفس  القواعد التي تم استخدامها لتقسيم بيانات التدريب الخاصة به.\n",
    "\n",
    "يُعد كل من [spaCy](https://spacy.io/) و [Moses](http://www.statmt.org/moses/?n=Development.GetStarted) هما مجزّئي النصوص التي تعتمد على القواعد\n",
    "الشائعة. عند تطبيقها على مثالنا، فإن *spaCy* و *Moses* ستخرج نّصًا مثل:\n",
    "\n",
    "```\n",
    "[\"Do\", \"n't\", \"you\", \"love\", \"🤗\", \"Transformers\", \"?\", \"We\", \"sure\", \"do\", \".\"]\n",
    "```\n",
    "\n",
    "كما يمكنك أن ترى، يتم هنا استخدام التقسيم المكاني والترقيم، وكذلك تقسيم الكلمات القائم على القواعد. يعد التقسيم المكاني والترقيم والتحليل القائم على القواعد كلاهما مثالين على تقسيم الكلمات، والذي يُعرّف بشكل غير مُحدد على أنه تقسيم  الجُمل إلى كلمات. في حين أنها الطريقة الأكثر بديهية لتقسيم النصوص إلى أجزاء أصغر،\n",
    "يمكن أنها تؤدى إلى مشكلات لمجموعات النصوص الضخمة. في هذه الحالة، عادةً ما يؤدي التقسيم المكاني والترقيم\n",
    "إلى إنشاء مفردات كبيرة جدًا (مجموعة من جميع الكلمات والرموز الفريدة المستخدمة). على سبيل المثال، يستخدم [Transformer XL](https://huggingface.co/docs/transformers/main/ar/model_doc/transfo-xl) التقسيم المكاني والترقيم، مما يؤدي إلى حجم مُفردات يبلغ 267735!\n",
    "\n",
    "يفرض حجم المُفردات الكبير هذا على النموذج أن يكون لديه مصفوفة تضمين (embedding matrix) ضخمة كطبقة إدخال وإخراج، مما يؤدي إلى زيادة كل من التعقيد الزمني والذاكرة. بشكل عام، نادرًا ما يكون لدى نماذج المحولات حجم مفردات\n",
    "أكبر من 50000، خاصة إذا تم تدريبها مسبقًا على لغة واحدة فقط.\n",
    "\n",
    "لذا إذا كان التقسيم المكاني و الترقيم البسيط غير مرضٍ، فلماذا لا نقسّم الحروف ببساطة؟"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/ssLq_EK2jLE?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title\n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/ssLq_EK2jLE?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "في حين أن تقسيم الأحرف بسيط للغاية ومن شأنه أن يقلل بشكل كبير من التعقيد الزمني والذاكرة، إلا أنه يجعل من الصعب\n",
    "على النموذج تعلم تمثيلات المدخلات ذات معنى. على سبيل المثال، يعد تعلم تمثيل مستقل عن السياق للحرف \"t\" أكثر صعوبة من تعلم تمثيل مستقل عن السياق لكلمة \"اليوم\". لذلك، غالبًا ما يكون تحليل الأحرف مصحوبًا بفقدان الأداء. لذا للحصول على أفضل ما في العالمين، تستخدم نماذج المحولات نظامًا  هجينًا  بين تقسيم على مستوى الكلمة وتقسيم علي مستوى الأحرف يسمى **تقسيم   الوحدات  الفرعية  للّغة**   (subword   tokenization)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## تقسيم الوحدات الفرعية للّغة (Subword Tokenization)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "form",
    "hide_input": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/zHvTiHr506c?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#@title\n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML('<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/zHvTiHr506c?rel=0&amp;controls=0&amp;showinfo=0\" frameborder=\"0\" allowfullscreen></iframe>')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "تعتمد خوارزميات تقسيم الوحدات الفرعية subword على المبدأ القائل بأن الكلمات الشائعة الاستخدام لا ينبغي تقسيمها إلى وحدات فرعية أصغر، ولكن يجب تفكيك الكلمات النادرة إلى رموز فرعية ذات معنى. على سبيل المثال، قد يتم اعتبار \"annoyingly\"\n",
    "كلمة نادرة ويمكن تحليلها إلى \"annoying\" و \"ly\". كل من \"annoying\" و \"ly\" كـ subwords مستقلة ستظهر بشكل متكرر أكثر في حين أن معنى \"annoyingly\" يتم الاحتفاظ به من خلال المعنى المركب لـ \"annoying\" و \"ly\". هذا مفيد بشكل خاص في اللغات التلصيقية مثل التركية، حيث يمكنك تشكيل كلمات مُركبة طويلة (تقريبًا) بشكل تعسفي عن طريق ضم الرموز الفرعية معًا.\n",
    "\n",
    "يسمح تقسيم subword للنموذج بأن يكون له حجم مفردات معقول مع القدرة على تعلم تمثيلات مستقلة عن السياق ذات معنى. بالإضافة إلى ذلك، يمكّن تقسيم subword النموذج من معالجة الكلمات التي لم يسبق له رؤيتها من قبل، عن طريق تحليلها إلى رموز فرعية معروفة. على سبيل المثال، يقوم المحلل `BertTokenizer` بتحليل\"I have a new GPU!\" كما يلي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"i\", \"have\", \"a\", \"new\", \"gp\", \"##u\", \"!\"]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from transformers import BertTokenizer\n",
    "\n",
    "tokenizer = BertTokenizer.from_pretrained(\"google-bert/bert-base-uncased\")\n",
    "tokenizer.tokenize(\"I have a new GPU!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "نظرًا  لأننا نستخدم  نموذجًا غير حساس لحالة الأحرف (uncased model)، فقد تم تحويل الجملة إلى أحرف صغيرة أولاً. يمكننا أن نرى أن الكلمات `[\"i\"، \"have\"، \"a\"، \"new\"]` موجودة في مفردات  مُجزّئ النصوص، ولكن الكلمة \"gpu\" غير موجودة. وبالتالي، يقوم مُجزّئ النصوص   بتقسيم \"gpu\" إلى رموز فرعية معروفة: `[\"gp\" و \"##u\"]`. يعني \"##\" أنه يجب ربط بقية الرمز بالرمز السابق، دون مسافة (للترميز أو عكس عملية  تقسيم  الرموز).\n",
    "\n",
    "كمثال آخر، يقوم المحلل `XLNetTokenizer` بتقسيم نّص مثالنا السابق كما يلي:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"▁Don\", \"'\", \"t\", \"▁you\", \"▁love\", \"▁\"، \"🤗\"، \"▁\"، \"Transform\"، \"ers\"، \"؟\"، \"▁We\"، \"▁sure\"، \"▁do\"، \".\"]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from transformers import XLNetTokenizer\n",
    "\n",
    "tokenizer = XLNetTokenizer.from_pretrained(\"xlnet/xlnet-base-cased\")\n",
    "tokenizer.tokenize(\"Don't you love 🤗 Transformers? We sure do.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "سنعود إلى معنى تلك `\"▁\"` عندما نلقي نظرة على [SentencePiece](#sentencepiece). كما يمكنك أن ترى،\n",
    "تم تقسيم الكلمة النادرة \"Transformers\" إلى الرموز الفرعية الأكثر تكرارًا `\"Transform\"` و `\"ers\"`.\n",
    "\n",
    "دعنا الآن نلقي نظرة على كيفية عمل خوارزميات تقسيم subword المختلفة. لاحظ أن جميع خوارزميات التقسيم هذه تعتمد على بعض أشكال التدريب الذي يتم عادةً على مجموعة البيانات التي سيتم تدريبها النموذج عليها.\n",
    "\n",
    "<a id='byte-pair-encoding'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ترميز الأزواج البايتية (BPE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "تم تقديم رميز أزواج البايت (BPE) في ورقة بحثية بعنوان [الترجمة الآلية العصبية للكلمات النادرة باستخدام وحدات subword (Sennrich et al.، 2015)](https://huggingface.co/papers/1508.07909). يعتمد BPE على مُجزّئ أولي يقسم بيانات التدريب إلى\n",
    "كلمات. يمكن أن يكون التحليل المسبق بسيطًا مثل التقسيم المكاني، على سبيل المثال [GPT-2](https://huggingface.co/docs/transformers/main/ar/model_doc/gpt2)، [RoBERTa](https://huggingface.co/docs/transformers/main/ar/model_doc/roberta). تشمل التقسيم الأكثر تقدمًا معتمد على التحليل القائم على القواعد، على سبيل المثال [XLM](https://huggingface.co/docs/transformers/main/ar/model_doc/xlm)، [FlauBERT](https://huggingface.co/docs/transformers/main/ar/model_doc/flaubert) الذي يستخدم Moses لمعظم اللغات، أو [GPT](https://huggingface.co/docs/transformers/main/ar/model_doc/openai-gpt) الذي يستخدم spaCy و ftfy، لحساب تكرار كل كلمة في مجموعة بيانات التدريب.\n",
    "\n",
    "بعد التحليل المسبق، يتم إنشاء مجموعة من الكلمات الفريدة وقد تم تحديد تكرار كل كلمة في تم تحديد بيانات التدريب. بعد ذلك، يقوم BPE بإنشاء مفردات أساسية تتكون من جميع الرموز التي تحدث في مجموعة الكلمات الفريدة ويتعلم قواعد الدمج لتشكيل رمز جديد من رمزين من المفردات الأساسية. إنه يفعل ذلك حتى تصل المفردات إلى حجم المفردات المطلوب. لاحظ أن حجم المفردات هو فرط معلمة لتحديد قبل تدريب مُجزّئ  النصوص.\n",
    "\n",
    "كمثال، دعنا نفترض أنه بعد  التقسيم    الأولي، تم تحديد مجموعة الكلمات التالية بما في ذلك تكرارها:\n",
    "\n",
    "```\n",
    "(\"hug\", 10), (\"pug\", 5), (\"pun\", 12), (\"bun\", 4), (\"hugs\", 5)\n",
    "```\n",
    "\n",
    "وبالتالي، فإن المفردات الأساسية هي `[\"b\"، \"g\"، \"h\"، \"n\"، \"p\"، \"s\"، \"u\"]`. من خلال تقسيم جميع الكلمات إلى رموز من\n",
    "المفردات الأساسية، نحصل على:\n",
    "\n",
    "```\n",
    "(\"h\" \"u\" \"g\"، 10)، (\"p\" \"u\" \"g\"، 5)، (\"p\" \"u\" \"n\"، 12)، (\"b\" \"u\" \"n\"، 4)، (\"h\" \"u\" \"g\" \"s\"، 5)\n",
    "```\n",
    "\n",
    "بعد ذلك، يقوم BPE بعدد مرات حدوث كل زوج من الرموز المحتملة ويختار زوج الرموز الذي يحدث بشكل متكرر. في\n",
    "في المثال أعلاه، يحدث \"h\" متبوعًا بـ \"u\" _10 + 5 = 15_ مرة (10 مرات في 10 مرات\n",
    "حدوث \"hug\"، 5 مرات في 5 مرات حدوث \"hugs\"). ومع ذلك، فإن أكثر أزواج الرموز شيوعًا هو \"u\" متبوعًا\n",
    "بواسطة \"g\"، والتي تحدث _10 + 5 + 5 = 20_ مرة في المجموع. وبالتالي، فإن أول قاعدة دمج يتعلمها المحلل هي تجميع جميع\n",
    "رموز \"u\" التي تتبعها \"g\" معًا. بعد ذلك، يتم إضافة \"ug\" إلى المفردات. تصبح مجموعة الكلمات\n",
    "\n",
    "```\n",
    "(\"h\" \"ug\"، 10)، (\"p\" \"ug\"، 5)، (\"p\" \"u\" \"n\"، 12)، (\"b\" \"u\" \"n\"، 4)، (\"h\" \"ug\" \"s\"، 5)\n",
    "```\n",
    "\n",
    "بعد ذلك، يحدد BPE ثاني أكثر أزواج الرموز شيوعًا. إنه \"u\" متبوعًا بـ \"n\"، والذي يحدث 16 مرة. \"u\"،\n",
    "يتم دمج \"n\" في \"un\" ويضاف إلى المفردات. ثالث أكثر أزواج الرموز شيوعًا هو \"h\" متبوعًا\n",
    "بواسطة \"ug\"، والتي تحدث 15 مرة. مرة أخرى يتم دمج الزوج ويتم إضافة \"hug\" إلى المفردات.\n",
    "\n",
    "في هذه المرحلة، تكون المفردات هي `[\"b\"، \"g\"، \"h\"، \"n\"، \"p\"، \"s\"، \"u\"، \"ug\"، \"un\"، \"hug\"]` ومجموعة الكلمات الفريدة لدينا\n",
    "تمثيله كما يلي:\n",
    "\n",
    "```\n",
    "(\"hug\", 10), (\"p\" \"ug\", 5), (\"p\" \"un\", 12), (\"b\" \"un\", 4), (\"hug\" \"s\", 5)\n",
    "```\n",
    "\n",
    "بافتراض أن تدريب ترميز الأزواج البايت سيتوقف عند هذه النقطة، فسيتم تطبيق قواعد الدمج التي تم تعلمها بعد ذلك على الكلمات الجديدة (طالما أن هذه الكلمات الجديدة لا تشمل رموزًا لم تكن في المفردات الأساسية). على سبيل المثال، سيتم تقسيم كلمة \"bug\" إلى `[\"b\"، \"ug\"]` ولكن سيتم تقسيم \"mug\" على أنها `[\"<unk>\"، \"ug\"]` نظرًا لأن الرمز \"m\" غير موجود في المفردات الأساسية. بشكل عام، لا يتم استبدال الأحرف الفردية مثل \"m\" بالرمز \"<unk>\" لأن بيانات التدريب تتضمن عادةً ظهورًا واحدًا على الأقل لكل حرف، ولكن من المحتمل أن يحدث ذلك لرموز خاصة جدًا مثل الرموز التعبيرية.\n",
    "\n",
    "كما ذكرنا سابقًا، فإن حجم المفردات، أي حجم المفردات الأساسية + عدد عمليات الدمج، هو معامل يجب اختياره. على سبيل المثال، لدى [GPT](https://huggingface.co/docs/transformers/main/ar/model_doc/openai-gpt) حجم مفردات يبلغ 40478 منذ أن كان لديهم 478 حرفًا أساسيًا واختاروا التوقف عن التدريب بعد 40,000 عملية دمج."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ترميز الأزواج البايتية على مستوى البايت"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "قد تكون المفردات الأساسية التي تتضمن جميع الأحرف الأساسية كبيرة جدًا إذا *على سبيل المثال* تم اعتبار جميع أحرف اليونيكود\n",
    "كأحرف أساسية. لذا، ليكون لديك مفردات أساسية أفضل، يستخدم [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) البايتات كمفردات أساسية، وهي حيلة ذكية لإجبار المفردات الأساسية على أن تكون بحجم 256 مع ضمان أن يتم تضمين كل حرف أساسي في المفردات. مع بعض القواعد الإضافية للتعامل مع علامات الترقيم، يمكن لمُجزّئ  النصوص GPT2 تجزئة أي نص دون الحاجة إلى رمز <unk>. لدى [GPT-2](https://huggingface.co/docs/transformers/main/ar/model_doc/gpt) حجم مفردات يبلغ 50257، والذي يتوافق مع رموز 256 base byte، ورمز خاص لنهاية النص والرموز التي تم تعلمها باستخدام 50000 عملية دمج.\n",
    "\n",
    "<a id='wordpiece'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WordPiece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "تعتبر WordPiece  خوارزمية تجزئة الكلمات الفرعية subword المستخدمة لـ [BERT](https://huggingface.co/docs/transformers/main/ar/model_doc/bert)، [DistilBERT](https://huggingface.co/docs/transformers/main/ar/model_doc/distilbert)، و [Electra](https://huggingface.co/docs/transformers/main/ar/model_doc/electra). تم توضيح الخوارزمية في [البحث الصوتي الياباني والكوري\n",
    "(Schuster et al.، 2012)](https://static.googleusercontent.com/media/research.google.com/ja//pubs/archive/37842.pdf) وهو مشابه جدًا\n",
    "BPE. أولاً، يقوم WordPiece بتكوين المفردات لتضمين كل حرف موجود في بيانات التدريب\n",
    "وتعلم تدريجياً عددًا معينًا من قواعد الدمج. على عكس BPE، لا يختار WordPiece أكثر زوج الرموز المتكررة، ولكن تلك التي تزيد من احتمال بيانات التدريب بمجرد إضافتها إلى المفردات.\n",
    "\n",
    "لذا، ماذا يعني هذا بالضبط؟ بالإشارة إلى المثال السابق، فإن زيادة احتمال بيانات التدريب تعادل إيجاد زوج الرموز، الذي يكون احتمال تقسيمه على احتمالات رمزه الأول تليها رمزه الثاني هو الأكبر بين جميع أزواج الرموز. *مثال* `\"u\"`، تليها `\"g\"` كانت قد اندمجت فقط إذا كان احتمال `\"ug\"` مقسومًا على `\"u\"`، `\"g\"` كان سيكون أكبر من أي زوج آخر من الرموز. بديهيًا، WordPiece مختلف قليلاً عن BPE في أنه يقيم ما يفقده عن طريق دمج رمزين للتأكد من أنه يستحق ذلك.\n",
    "\n",
    "<a id='unigram'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unigram"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unigram هو خوارزمية توكنيز subword التي تم تقديمها في [تنظيم subword: تحسين نماذج الترجمة الشبكة العصبية\n",
    "نماذج مع مرشحين subword متعددة (Kudo، 2018)](https://huggingface.co/papers/1804.10959). على عكس BPE أو\n",
    "WordPiece، يقوم Unigram بتكوين مفرداته الأساسية إلى عدد كبير من الرموز ويقللها تدريجياً للحصول على مفردات أصغر. يمكن أن تتوافق المفردات الأساسية على سبيل المثال مع جميع الكلمات المسبقة التوكنز والسلاسل الفرعية الأكثر شيوعًا. لا يتم استخدام Unigram مباشرة لأي من النماذج في المحولات، ولكنه يستخدم بالاقتران مع [SentencePiece](#sentencepiece).\n",
    "\n",
    "في كل خطوة تدريب، يحدد خوارزمية Unigram خسارة (غالبًا ما يتم تعريفها على أنها اللوغاريتم) عبر بيانات التدريب بالنظر إلى المفردات الحالية ونموذج اللغة unigram. بعد ذلك، بالنسبة لكل رمز في المفردات، يحسب الخوارزمية مقدار زيادة الخسارة الإجمالية إذا تم إزالة الرمز من المفردات. ثم يقوم Unigram بإزالة p (مع p عادة ما تكون 10% أو 20%) في المائة من الرموز التي تكون زيادة الخسارة فيها هي الأدنى، *أي* تلك\n",
    "الرموز التي تؤثر أقل على الخسارة الإجمالية عبر بيانات التدريب. تتكرر هذه العملية حتى تصل المفردات إلى الحجم المطلوب. يحتفظ خوارزمية Unigram دائمًا بالشخصيات الأساسية بحيث يمكن توكنز أي كلمة.\n",
    "\n",
    "نظرًا لأن Unigram لا يعتمد على قواعد الدمج (على عكس BPE وWordPiece)، فإن للخوارزمية عدة طرق\n",
    "توكنز نص جديد بعد التدريب. على سبيل المثال، إذا كان محول Unigram المدرب يعرض المفردات:\n",
    "\n",
    "```\n",
    "[\"b\"، \"g\"، \"h\"، \"n\"، \"p\"، \"s\"، \"u\"، \"ug\"، \"un\"، \"hug\"]،\n",
    "```\n",
    "\n",
    "يمكن توكنز `\"hugs\"` على أنه `[\"hug\"، \"s\"]`، أو `[\"h\"، \"ug\"، \"s\"]` أو `[\"h\"، \"u\"، \"g\"، \"s\"]`. إذن ماذا\n",
    "لاختيار؟ يحفظ Unigram احتمال كل رمز في فيلق التدريب بالإضافة إلى حفظ المفردات بحيث\n",
    "يمكن حساب احتمال كل توكنز ممكن بعد التدريب. ببساطة، يختار الخوارزمية الأكثر\n",
    "توكنز المحتملة في الممارسة، ولكنه يوفر أيضًا إمكانية أخذ عينات من توكنز ممكن وفقًا لاحتمالاتها.\n",
    "\n",
    "تتم تعريف هذه الاحتمالات بواسطة الخسارة التي يتم تدريب المحول عليها. بافتراض أن بيانات التدريب تتكون\n",
    "من الكلمات $x_{1}، \\dots، x_{N}$ وأن مجموعة جميع التوكنزات الممكنة لكلمة $x_{i}$ هي\n",
    "يتم تعريفها على أنها $S(x_{i})$، ثم يتم تعريف الخسارة الإجمالية على النحو التالي\n",
    "\n",
    "$$\\mathcal{L} = -\\sum_{i=1}^{N} \\log \\left ( \\sum_{x \\in S(x_{i})} p(x) \\right )$$\n",
    "\n",
    "<a id='sentencepiece'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SentencePiece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "تحتوي جميع خوارزميات توكنز الموصوفة حتى الآن على نفس المشكلة: من المفترض أن النص المدخل يستخدم المسافات لفصل الكلمات. ومع ذلك، لا تستخدم جميع اللغات المسافات لفصل الكلمات. أحد الحلول الممكنة هو استخداممعالج مسبق للغة محدد، *مثال* [XLM](https://huggingface.co/docs/transformers/main/ar/model_doc/xlm) يلذي يستخدم معالجات مسبقة محددة للصينية واليابانية والتايلاندية.\n",
    "لحل هذه المشكلة بشكل أعم، [SentencePiece: A simple and language independent subword tokenizer and\n",
    "detokenizer for Neural Text Processing (Kudo et al.، 2018)](https://huggingface.co/papers/1808.06226) يتعامل مع المدخلات\n",
    "كتدفق بيانات خام، وبالتالي يشمل المسافة في مجموعة الأحرف التي سيتم استخدامها. ثم يستخدم خوارزمية BPE أو unigram\n",
    "لبناء المفردات المناسبة.\n",
    "\n",
    "يستخدم `XLNetTokenizer` SentencePiece على سبيل المثال، وهو أيضًا سبب تضمين تم تضمين حرف `\"▁\"` في المفردات. عملية فك التشفير باستخدام SentencePiece سهلة للغاية نظرًا لأنه يمكن دائمًا دمج الرموز معًا واستبدال `\"▁\"` بمسافة.\n",
    "\n",
    "تستخدم جميع نماذج المحولات في المكتبة التي تستخدم SentencePiece بالاقتران مع unigram. أمثلة على النماذج\n",
    "باستخدام SentencePiece هي [ALBERT](https://huggingface.co/docs/transformers/main/ar/model_doc/albert)، [XLNet](https://huggingface.co/docs/transformers/main/ar/model_doc/xlnet)، [Marian](https://huggingface.co/docs/transformers/main/ar/model_doc/marian)، و [T5](https://huggingface.co/docs/transformers/main/ar/model_doc/t5)."
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 4
}
